package com.douma.第26天;

import java.util.*;

/**
 * 抖码算法，让算法学习变的简单有趣
 *
 * @作者 : 老汤
 */
public class 服务失效判断 {
    private static Map<String, Set<String>> graph;
    // 用于存储最终的无效的服务
    private static TreeSet<String> invalidServiceSet = new TreeSet<>();

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        String[] dependencies = sc.nextLine().split(",");
        // 存储所有的服务
        List<String> serviceList = new ArrayList<>();
        graph = new HashMap<>();
        for (String dep : dependencies) { // 遍历所有的服务依赖，建立图结构
            String[] services = dep.split("-");
            // a-b：表示的是 a 服务依赖于 b，
            String a = services[0];
            String b = services[1];
            // 不过这里边的方向是 b 到 a，即： a<--b
            // 即维护服务 b 以及依赖它的所有的其他服务
            if (graph.containsKey(b)) {
                graph.get(b).add(a);
            } else {
                Set<String> set = new TreeSet<>();
                set.add(a);
                graph.put(b, set);
            }

            // 如果 a 或者 b 在前面没有出现过，则放入到服务列表中
            if (!serviceList.contains(a)) {
                serviceList.add(a);
            }
            if (!serviceList.contains(b)) {
                serviceList.add(b);
            }
        }
        // 给定的失效服务列表
        String[] invalidServices = sc.nextLine().split(",");
        for (String invalidService : invalidServices) {
            // 如果当前的失效服务不在最终的失效服务集里
            if (!invalidServiceSet.contains(invalidService)) {
                // 那么从这个失效服务开始，找到依赖这个服务的所有其他的服务，并将它们失效
                dfs(invalidService);
            }
        }

        // 输出结果
        StringBuilder res = new StringBuilder();
        for (int i = 0; i < serviceList.size(); i++) {
            if (!invalidServiceSet.contains(serviceList.get(i))) {
                res.append(serviceList.get(i));
                res.append(",");
            }
        }

        if (res.length() == 0) {
            System.out.println(",");
        } else {
            // 删除最后的逗号
            res.deleteCharAt(res.length() - 1);
            System.out.println(res);
        }

        sc.close();
    }

    /**
     * 从指定失效服务开始，找到依赖这个服务的所有其他的服务，并将它们失效
     * @param invalidService
     */
    private static void dfs(String invalidService) {
        // 放入到失效服务集中
        invalidServiceSet.add(invalidService);

        // 如果图中不存在这个失效服务，则直接返回
        if (!graph.containsKey(invalidService)) {
            return;
        }

        // 遍历直接依赖这个失效服务的其他服务，使其失效
        for (String w : graph.get(invalidService)) {
            if (!invalidServiceSet.contains(w)) {
                dfs(w);
            }
        }
    }
}
